﻿//using System;
//using System.Collections.Generic;
//using System.Linq;
//using System.Text;
//using System.Diagnostics;
//using MongoDB.Driver;
//using MongoDB.Driver.Linq;
//using MongoDB.Driver.Builders;
//using MongoDB.Bson;
//using System.Collections.Concurrent;
//using MongoDB.Bson.Serialization.Options;

//namespace QuotationService.HistoryQuotation
//{
//    /// <summary>
//    /// 历史数据发布集合类
//    /// </summary>
//    internal class QuotationArchiverCollection
//    {
//        /// <summary>
//        /// MongoDB的客户端实例
//        /// </summary>
//        protected MongoClient _MongoClient = null;

//        /// <summary>
//        /// 行情源类型
//        /// </summary>
//        public QuotationSource Source { get; private set; }

//        /// <summary>
//        /// 数据库名称
//        /// </summary>
//        public string DBName { get { return this.Source.ToString(); } }

//        /// <summary>
//        /// 构造器
//        /// </summary>
//        /// <param name="source"></param>
//        /// <param name="client"></param>
//        [DebuggerNonUserCode]
//        public QuotationArchiverCollection(QuotationSource source, MongoClient client)
//        {
//            this.Source = source;
//            this._MongoClient = client;
//        }

//        /// <summary>
//        /// 获取归档数据的集合名称
//        /// </summary>
//        /// <param name="type">归档数据类型</param>
//        /// <returns></returns>
//        protected string GetCollectionName(QuotationArchiverType type)
//        {
//            return string.Format("{0}", type.ToString());
//        }

//        /// <summary>
//        /// 获取集合对象
//        /// </summary>
//        /// <typeparam name="T"></typeparam>
//        /// <param name="type"></param>
//        /// <returns></returns>
//        protected MongoCollection GetCollection<T>(QuotationArchiverType type) where T : class
//        {
//            if (_MongoClient == null)
//                return null;

//            MongoServer server = _MongoClient.GetServer();
//            if (server == null)
//                return null;

//            MongoDatabase database = server.GetDatabase(this.Source.ToString());
//            if (database == null)
//                return null;

//            return database.GetCollection(typeof(T), GetCollectionName(type));
//        }
//    }

//    #region 交易日归档集合

//    /// <summary>
//    /// 归档执行情况统计数据类
//    /// </summary>
//    public class ArchiverStatus
//    {
//        /// <summary>
//        /// id
//        /// </summary>
//        public ObjectId _id;

//        /// <summary>
//        /// 交易日（格式yyyyMMdd）
//        /// </summary>
//        public UInt32 TradeDay { get; set; }

//        /// <summary>
//        /// 基本信息归档成功记录数
//        /// </summary>
//        public UInt32 BasicInfoSuccess { get; set; }

//        /// <summary>
//        /// 基本信息归档失败记录数
//        /// </summary>
//        public UInt32 BasicInfoFailed { get; set; }

//        /// <summary>
//        /// 行情信息归档成功记录数
//        /// </summary>
//        public UInt32 QuotationInfoSuccess { get; set; }

//        /// <summary>
//        /// 行情信息归档失败记录数
//        /// </summary>
//        public UInt32 QuotationInfoFailed { get; set; }

//        /// <summary>
//        /// Tick信息归档成功记录数
//        /// </summary>
//        public UInt32 TickInfoSuccess { get; set; }

//        /// <summary>
//        /// Tick信息归档失败记录数
//        /// </summary>
//        public UInt32 TickInfoFailed { get; set; }

//        /// <summary>
//        /// 分线数据归档成功记录数
//        /// </summary>
//        public UInt32 MinuteDataSuccess { get; set; }

//        /// <summary>
//        /// 分线数据归档失败记录数
//        /// </summary>
//        public UInt32 MinuteDataFailed { get; set; }

//        /// <summary>
//        /// 日线数据归档成功记录数
//        /// </summary>
//        public UInt32 DailyDataSuccess { get; set; }

//        /// <summary>
//        /// 日线数据归档失败记录数
//        /// </summary>
//        public UInt32 DailyDataFailed { get; set; }

//        /// <summary>
//        /// 最后更新时间（格式yyyyMMddhhmmss）
//        /// </summary>
//        public UInt64 LastUpdatedTime { get; set; }
//    }

//    /// <summary>
//    /// 交易日归档集合
//    /// </summary>
//    internal class ArchiverStatusCollection : QuotationArchiverCollection
//    {
//        /// <summary>
//        /// 数据集合
//        /// </summary>
//        private MongoCollection _Collection = null;

//        /// <summary>
//        /// 构造器
//        /// </summary>
//        /// <param name="source"></param>
//        /// <param name="client"></param>
//        [DebuggerNonUserCode]
//        public ArchiverStatusCollection(QuotationSource source, MongoClient client)
//            : base(source, client)
//        {
//            _Collection = GetCollection<ArchiverStatus>(QuotationArchiverType.ArchiverStatus);
//            if (_Collection == null)
//                throw new Exception(string.Format("初始化数据集合失败，Source:{0}, Code:TradeDay", source));
//        }

//        /// <summary>
//        /// 将归档状态统计数据归档
//        /// </summary>
//        /// <param name="status"></param>
//        /// <returns></returns>
//        public bool Archive(ArchiverStatus status)
//        {
//            if (_Collection == null)
//                return false;

//            IMongoQuery query = Query.EQ("TradeDay", status.TradeDay);

//            WriteConcernResult result = null;
//            var preValue = _Collection.FindOneAs<ArchiverStatus>(query);
//            if (preValue != null)
//            {
//                status._id = preValue._id;
//                IMongoUpdate update = Update.Replace(status);
//                result = _Collection.Update(query, update, UpdateFlags.Upsert);
//            }
//            else
//            {
//                result = _Collection.Insert(status);
//            }

//            return result.Ok;
//        }

//        /// <summary>
//        /// 查询所有交易日的归档统计数据
//        /// </summary>
//        /// <returns></returns>
//        public List<ArchiverStatus> GetDatas()
//        {
//            List<ArchiverStatus> result = new List<ArchiverStatus>();

//            var tradedays = _Collection.FindAllAs<ArchiverStatus>();
//            foreach (var item in tradedays)
//                result.Add(item);

//            return result;
//        }

//        /// <summary>
//        /// 查询指定交易日的归档统计数据
//        /// </summary>
//        /// <returns></returns>
//        public ArchiverStatus GetDatas(uint tradeday)
//        {
//            return _Collection.AsQueryable<ArchiverStatus>()
//                                .Where(x => x.TradeDay == tradeday).FirstOrDefault();
//        }
//        /// <summary>
//        /// 查询最新的交易日归档统计数据
//        /// </summary>
//        /// <returns></returns>
//        public ArchiverStatus GetLatestData()
//        {
//            return _Collection.AsQueryable<ArchiverStatus>().OrderBy(x => x.TradeDay).LastOrDefault();
//        }
//    }

//    #endregion

//    #region 现货行情归档集合类

//    /// <summary>
//    /// 基本信息归档集合
//    /// </summary>
//    internal class StockBasicInfoArchiverCollection : QuotationArchiverCollection
//    {
//        /// <summary>
//        /// 数据集合
//        /// </summary>
//        private MongoCollection _Collection = null;

//        /// <summary>
//        /// 构造器
//        /// </summary>
//        /// <param name="source"></param>
//        /// <param name="client"></param>
//        [DebuggerNonUserCode]
//        public StockBasicInfoArchiverCollection(QuotationSource source, MongoClient client)
//            : base(source, client)
//        {
//            _Collection = GetCollection<StockBasicInfo>(QuotationArchiverType.BasicInfo);
//            if (_Collection == null)
//                throw new Exception(string.Format("初始化数据集合失败，Source:{0}", source));
//        }

//        /// <summary>
//        /// 将基本信息归档
//        /// </summary>
//        /// <param name="basicInfo"></param>
//        /// <returns></returns>
//        public bool Archive(StockBasicInfo basicInfo)
//        {
//            if (_Collection == null)
//                return false;
//            IMongoQuery query = Query.And(
//                       Query.EQ("Code", basicInfo.Code),
//                       Query.EQ("TradeDay", basicInfo.TradeDay));

//            WriteConcernResult result = null;
//            var preValue = _Collection.FindOneAs<StockBasicInfo>(query);
//            if (preValue != null)
//            {
//                basicInfo._id = preValue._id;
//                IMongoUpdate update = Update.Replace(basicInfo);
//                result = _Collection.Update(query, update, UpdateFlags.Upsert);
//            }
//            else
//            {
//                result = _Collection.Insert(basicInfo);
//            }

//            return result.Ok;
//        }

//        /// <summary>
//        /// 查询单代码指定交易日的基本资料
//        /// </summary>
//        /// <param name="code">证券代码</param>
//        /// <param name="tradeday">交易日</param>
//        /// <returns></returns>
//        public StockBasicInfo GetBasicInfoByTradeDay(string code, uint tradeday)
//        {
//            if (string.IsNullOrEmpty(code) || _Collection == null)
//                return null;

//            return _Collection.AsQueryable<StockBasicInfo>()
//                .Where(x => x.TradeDay == tradeday && x.Code.Equals(code)).FirstOrDefault();
//        }

//        /// <summary>
//        /// 取指定交易日的所有基本资料
//        /// </summary>
//        /// <param name="tradeDay"></param>
//        /// <returns></returns>
//        public List<StockBasicInfo> GetBasicInfosByTradeDay(uint tradeDay)
//        {
//            if (_Collection == null)
//                return null;
//            return _Collection.AsQueryable<StockBasicInfo>()
//             .Where(x => x.TradeDay == tradeDay ).ToList();
//        }
//    }

//    /// <summary>
//    /// 基本信息归档集合
//    /// </summary>
//    internal class StockQuotationInfoArchiverCollection : QuotationArchiverCollection
//    {
//        /// <summary>
//        /// 数据集合
//        /// </summary>
//        private MongoCollection _Collection = null;

//        /// <summary>
//        /// 构造器
//        /// </summary>
//        /// <param name="source"></param>
//        /// <param name="client"></param>
//        [DebuggerNonUserCode]
//        public StockQuotationInfoArchiverCollection(QuotationSource source, MongoClient client)
//            : base(source, client)
//        {
//            _Collection = GetCollection<StockQuotationInfo>(QuotationArchiverType.QuotationInfo);
//            if (_Collection == null)
//                throw new Exception(string.Format("初始化数据集合失败，Source:{0}", source));
//        }

//        /// <summary>
//        /// 将基本信息归档
//        /// </summary>
//        /// <param name="quotationInfo"></param>
//        /// <returns></returns>
//        public bool Archive(StockQuotationInfo quotationInfo)
//        {
//            if (_Collection == null)
//                return false;
//            IMongoQuery query = Query.And(
//             Query.EQ("Code", quotationInfo.Code),
//             Query.EQ("TradeDay", quotationInfo.TradeDay));

//            WriteConcernResult result = null;
//            var preValue = _Collection.FindOneAs<StockQuotationInfo>(query);
//            if (preValue != null)
//            {
//                quotationInfo._id = preValue._id;
//                IMongoUpdate update = Update.Replace(quotationInfo);
//                result = _Collection.Update(query, update, UpdateFlags.Upsert);
//            }
//            else
//            {
//                result = _Collection.Insert(quotationInfo);
//            }

//            return result.Ok;

//        }

//        /// <summary>
//        /// 查询单代码指定交易日的行情资料
//        /// </summary>
//        /// <param name="code">证券代码</param>
//        /// <param name="tradeday">交易日</param>
//        /// <returns></returns>
//        public StockQuotationInfo GetQuotInfoByTradeDay(string code, uint tradeday)
//        {
//            if (string.IsNullOrEmpty(code) || _Collection == null)
//                return null;

//            return _Collection.AsQueryable<StockQuotationInfo>()
//                .Where(x => x.TradeDay == tradeday && x.Code.Equals(code)).FirstOrDefault();
//        }
//        public List<StockQuotationInfo> GetQuotInfosByTradeDay(uint tradeDay)
//        {
//            if (_Collection == null)
//                return null;

//            return _Collection.AsQueryable<StockQuotationInfo>()
//                .Where(x => x.TradeDay == tradeDay).ToList();
//        }
//    }

//    /// <summary>
//    /// 逐笔信息归档集合
//    /// </summary>
//    internal class StockTickInfoArchiverCollection : QuotationArchiverCollection
//    {
//        /// <summary>
//        /// 数据集合
//        /// </summary>
//        private MongoCollection _Collection = null;

//        /// <summary>
//        /// 构造器
//        /// </summary>
//        /// <param name="source"></param>
//        /// <param name="client"></param>
//        [DebuggerNonUserCode]
//        public StockTickInfoArchiverCollection(QuotationSource source, MongoClient client)
//            : base(source, client)
//        {
//            _Collection = GetCollection<StockTickInfo>(QuotationArchiverType.TickInfo);
//            if (_Collection == null)
//                throw new Exception(string.Format("初始化数据集合失败，Source:{0}", source));
//        }

//        /// <summary>
//        /// 将逐笔信息归档
//        /// </summary>
//        /// <param name="tickInfo"></param>
//        /// <returns></returns>
//        public bool Archive(StockTickInfo tickInfo)
//        {
//            if (_Collection == null)
//                return false;
//            IMongoQuery query = Query.And(
// Query.EQ("Code", tickInfo.Code),
// Query.EQ("TradeDay", tickInfo.TradeDay),
// Query.EQ("Sequence", tickInfo.Sequence));

//            WriteConcernResult result = null;
//            var preValue = _Collection.FindOneAs<StockTickInfo>(query);
//            if (preValue != null)
//            {
//                tickInfo._id = preValue._id;
//                IMongoUpdate update = Update.Replace(tickInfo);
//                result = _Collection.Update(query, update, UpdateFlags.Upsert);
//            }
//            else
//            {
//                result = _Collection.Insert(tickInfo);
//            }
//            return result.Ok;
//        }

//        /// <summary>
//        /// 查询单代码指定交易日的Tick资料
//        /// </summary>
//        /// <param name="code">证券代码</param>
//        /// <param name="tradeday">交易日</param>
//        /// <returns></returns>
//        public List<StockTickInfo> GetTicksByTradeDay(string code, uint tradeday)
//        {
//            if (string.IsNullOrEmpty(code) || _Collection == null)
//                return null;

//            return _Collection.AsQueryable<StockTickInfo>()
//                .Where(x => x.TradeDay == tradeday && x.Code.Equals(code)).ToList();
//        }
//    }

//    /// <summary>
//    /// 日线数据归档集合
//    /// </summary>
//    internal class StockDailyDataArchiverCollection : QuotationArchiverCollection
//    {
//        /// <summary>
//        /// 同步对象
//        /// </summary>
//        private static object SyncRoot = new object();

//        /// <summary>
//        /// 归档类型
//        /// </summary>
//        private static QuotationArchiverType ArchiverType = QuotationArchiverType.DailyData;

//        /// <summary>
//        /// 数据集合
//        /// </summary>
//        private static ConcurrentDictionary<QuotationSource, MongoCollection> _Collections = new ConcurrentDictionary<QuotationSource, MongoCollection>();

//        /// <summary>
//        /// 构造器
//        /// </summary>
//        /// <param name="source"></param>
//        /// <param name="client"></param>
//        [DebuggerNonUserCode]
//        public StockDailyDataArchiverCollection(QuotationSource source, MongoClient client)
//            : base(source, client)
//        {
//            lock (SyncRoot)
//            {
//                if (!_Collections.ContainsKey(source))
//                {
//                    _Collections[source] = GetCollection<StockDailyData>(ArchiverType);
//                    if (_Collections[source] == null)
//                        throw new Exception(string.Format("初始化数据集合失败，Source:{0}", source));
//                }
//            }
//        }

//        /// <summary>
//        /// 将日线数据归档
//        /// </summary>
//        /// <param name="dailyData"></param>
//        /// <returns></returns>
//        public bool Archive(StockDailyData dailyData)
//        {
//            if (!_Collections.ContainsKey(this.Source))
//                return false;

//            IMongoQuery query = Query.And(
//                        Query.EQ("Code", dailyData.Code),
//                        Query.EQ("TradeDay", dailyData.TradeDay));



//            WriteConcernResult result = null;
//            var preValue = _Collections[this.Source].FindOneAs<StockDailyData>(query);
//            if (preValue != null)
//            {
//                dailyData._id = preValue._id;
//                IMongoUpdate update = Update.Replace(dailyData);
//                result = _Collections[this.Source].Update(query, update, UpdateFlags.Upsert);
//            }
//            else
//            {
//                result = _Collections[this.Source].Insert(dailyData);
//            }

//            // 返回执行状态
//            return result.Ok;
//        }

//        /// <summary>
//        /// 查询单代码指定交易日的所有日线数据
//        /// </summary>
//        /// <param name="code">证券代码</param>
//        /// <param name="tradeday">交易日</param>
//        /// <returns></returns>
//        public StockDailyData GetDatasByTradeDay(string code, uint tradeday)
//        {
//            if (!_Collections.ContainsKey(this.Source))
//                return null;

//            if (string.IsNullOrEmpty(code))
//                return null;

//            return _Collections[this.Source].AsQueryable<StockDailyData>()
//                .Where(x => x.TradeDay == tradeday && x.Code.Equals(code)).FirstOrDefault();
//        }

//        /// <summary>
//        /// 查询单代码指定交易日范围内的所有日线数据
//        /// </summary>
//        /// <param name="code">证券代码</param>
//        /// <param name="startTradeday">起始交易日, 查询成功是，返回结果中第一条记录在全部数据中的序号</param>
//        /// <param name="endTradeday">结束交易日, 查询成功是，返回结果中最后一条记录在全部数据中的序号</param>
//        /// <returns></returns>
//        public List<StockDailyData> GetDatasByTradeDay(string code, ref uint startTradeday, ref uint endTradeday)
//        {
//            List<StockDailyData> result = new List<StockDailyData>();

//            if (!_Collections.ContainsKey(this.Source))
//                return result;

//            if (string.IsNullOrEmpty(code))
//                return result;

//            uint start = startTradeday;
//            uint end = endTradeday;

//            // 查询结果数据
//            var dailyDatas = _Collections[this.Source].AsQueryable<StockDailyData>()
//                .Where(x => x.TradeDay >= start && x.TradeDay <= end && x.Code.Equals(code));

//            // 处理结果
//            foreach (var dailydata in dailyDatas)
//            {
//                result.Add(dailydata);
//            }

//            // 如果数据不为空，则查询起始序号
//            if (result.Count != 0)
//            {
//                int startIndex = _Collections[this.Source].AsQueryable<StockDailyData>()
//                    .Where(x => x.Code.Equals(code) && x.TradeDay < start).Count();

//                startTradeday = (uint)startIndex;
//                endTradeday = startTradeday + (uint)result.Count - 1;
//            }

//            return result;
//        }

//        /// <summary>
//        /// 查询单代码指定起、止序号的所有日线数据
//        /// </summary>
//        /// <param name="code">证券代码</param>
//        /// <param name="startIndex">起始序号, 查询成功是，返回结果中第一条记录在全部数据中的序号</param>
//        /// <param name="endIndex">结束序号, 查询成功是，返回结果中最后一条记录在全部数据中的序号</param>
//        /// <returns></returns>
//        public List<StockDailyData> GetDatasByIndex(string code, ref int startIndex, ref int endIndex)
//        {
//            List<StockDailyData> result = new List<StockDailyData>();

//            if (!_Collections.ContainsKey(this.Source))
//                return result;

//            if (string.IsNullOrEmpty(code))
//                return result;

//            // 检查序号是否有效
//            if (startIndex >= 0 && startIndex > endIndex)
//                return result;
//            else if (startIndex < 0 && startIndex < endIndex)
//                return result;

//            int totalcount = _Collections[this.Source].AsQueryable<StockDailyData>()
//                    .Where(x => x.Code.Equals(code)).Count();


//            // 如果是倒序，则转换成正序
//            if (startIndex < 0)
//            {
//                int expectedCount = (int)Math.Abs(startIndex - endIndex + 1);
//                startIndex = totalcount + endIndex;
//                if (startIndex < 0)
//                    startIndex = 0;
//                endIndex = startIndex + expectedCount - 1;
//                if (endIndex >= totalcount)
//                    endIndex = totalcount - 1;
//            }
//            else
//            {
//                if (startIndex >= totalcount)
//                    return result;
//                if (endIndex >= totalcount)
//                    endIndex = totalcount - 1;
//            }

//            int skipCount = startIndex;
//            int takeCount = endIndex - startIndex + 1;
//            var dailyDatas = _Collections[this.Source].AsQueryable<StockDailyData>()
//                                .Where(x => x.Code.Equals(code))
//                                .OrderBy(x => x.TradeDay)
//                                .Skip(skipCount)
//                                .Take(takeCount);

//            foreach (var dailydata in dailyDatas)
//                result.Add(dailydata);

//            return result;
//        }

//        /// <summary>
//        /// 查询单代码的所有日线数据
//        /// </summary>
//        /// <param name="code">证券代码</param>
//        /// <returns></returns>
//        public List<StockDailyData> GetAllDatas(string code)
//        {
//            if (!_Collections.ContainsKey(this.Source))
//                return new List<StockDailyData>();

//            if (string.IsNullOrEmpty(code))
//                return new List<StockDailyData>();

//            // 查询结果数据
//            return _Collections[this.Source].AsQueryable<StockDailyData>()
//                .Where(x => x.Code.Equals(code)).ToList();
//        }

//        /// <summary>
//        /// 取日线的总数
//        /// </summary>
//        /// <param name="code"></param>
//        /// <returns></returns>
//        public int GetTotalCount(string code)
//        {
//            return _Collections[this.Source].AsQueryable<StockDailyData>()
//                .Where(x => x.Code.Equals(code)).Count();
//        }

//        /// <summary>
//        /// 查询给定交易日在数据中的序号
//        /// </summary>
//        /// <param name="code"></param>
//        /// <param name="tradeday"></param>
//        /// <returns>
//        ///             如果入参错误，则返回Int32.MinValue，
//        ///             如果给定交易日早于第一条数据，则返回-1，
//        ///             其它，则返回序号（实际按小于给定交易日的数据记录条数的汇总数）
//        /// </returns>
//        public int GetSequenceNoOfTradeday(string code, uint tradeday)
//        {
//            if (!_Collections.ContainsKey(this.Source))
//                return Int32.MinValue;

//            if (string.IsNullOrEmpty(code))
//                return Int32.MinValue;

//            var data = GetDatasByTradeDay(code, tradeday);
//            int count = _Collections[this.Source].AsQueryable<StockDailyData>()
//                .Where(x => x.Code.Equals(code) && x.TradeDay < tradeday).Count();

//            if (count == 0)
//                return data == null ? -1 : 0;
//            return count;
//        }
//    }

//    /// <summary>
//    /// 分线数据归档集合
//    /// </summary>
//    internal class StockMinuteDataArchiverCollection : QuotationArchiverCollection
//    {
//        /// <summary>
//        /// 同步对象
//        /// </summary>
//        private static object SyncRoot = new object();

//        /// <summary>
//        /// 归档类型
//        /// </summary>
//        private static QuotationArchiverType ArchiverType = QuotationArchiverType.MinuteData;

//        /// <summary>
//        /// 数据集合
//        /// </summary>
//        private static ConcurrentDictionary<QuotationSource, MongoCollection> _Collections = new ConcurrentDictionary<QuotationSource, MongoCollection>();

//        /// <summary>
//        /// 构造器
//        /// </summary>
//        /// <param name="source"></param>
//        /// <param name="client"></param>
//        [DebuggerNonUserCode]
//        public StockMinuteDataArchiverCollection(QuotationSource source, MongoClient client)
//            : base(source, client)
//        {
//            lock (SyncRoot)
//            {
//                if (!_Collections.ContainsKey(source))
//                {
//                    _Collections[source] = GetCollection<StockMinuteData>(ArchiverType);
//                    if (_Collections[source] == null)
//                        throw new Exception(string.Format("初始化数据集合失败，Source:{0}", source));
//                }
//            }
//        }

//        /// <summary>
//        /// 将分线数据归档
//        /// </summary>
//        /// <param name="minuteData"></param>
//        /// <returns></returns>
//        public bool Archive(StockMinuteData minuteData)
//        {
//            if (!_Collections.ContainsKey(this.Source))
//                return false;

//            IMongoQuery query = Query.And(
//Query.EQ("Code", minuteData.Code),
//Query.EQ("TradeDay", minuteData.TradeDay));
//            WriteConcernResult result = null;
//            var preValue = _Collections[this.Source].FindOneAs<StockMinuteData>(query);
//            if (preValue != null)
//            {
//                minuteData._id = preValue._id;
//                IMongoUpdate update = Update.Replace(minuteData);
//                result = _Collections[this.Source].Update(query, update, UpdateFlags.Upsert);
//            }
//            else
//            {
//                result = _Collections[this.Source].Insert(minuteData);
//            }

//            return result.Ok;
//        }

//        /// <summary>
//        /// 查询单代码指定交易日的所有分线数据
//        /// </summary>
//        /// <param name="code">证券代码</param>
//        /// <param name="tradeday">交易日</param>
//        /// <returns></returns>
//        public StockMinuteData GetDatasByTradeDay(string code, uint tradeday)
//        {
//            if (!_Collections.ContainsKey(this.Source))
//                return null;

//            if (string.IsNullOrEmpty(code))
//                return null;

//            return _Collections[this.Source].AsQueryable<StockMinuteData>()
//                                .Where(x => x.TradeDay == tradeday && x.Code.Equals(code)).FirstOrDefault();
//        }

     
//        /// <summary>
//        /// 查询单代码指定交易日范围内的所有分线数据
//        /// </summary>
//        /// <param name="code">证券代码</param>
//        /// <param name="startTradeday">起始日期</param>
//        /// <param name="endTradeday">结束日期</param>
//        /// <param name="startIndex">返回结果中第一条记录在全部数据中的序号</param>
//        /// <param name="endIndex">返回结果中最后一条记录在全部数据中的序号</param>
//        /// <returns></returns>
//        public List<StockMinuteData> GetDatasByTradeDay(string code,  uint startTradeday,  uint endTradeday,out uint startIndex,out uint endIndex)
//        {
//            List<StockMinuteData> result = new List<StockMinuteData>();
//            startIndex = 0;
//            endIndex = 0;
//            if (!_Collections.ContainsKey(this.Source) || string.IsNullOrEmpty(code))
//            {
//                return result;
//            }


//            // 查询结果数据
//            var minuteDatas = _Collections[this.Source].AsQueryable<StockMinuteData>()
//                                .Where(x => x.TradeDay >= startTradeday && x.TradeDay <= endTradeday && x.Code.Equals(code));

//            // 处理结果
//            foreach (var minutedata in minuteDatas)
//                result.Add(minutedata);

//            // 如果数据不为空，则查询起始序号
//            if (result.Count != 0)
//            {
//                 startIndex =(uint) _Collections[this.Source].AsQueryable<StockMinuteData>()
//                    .Where(x => x.Code.Equals(code) && x.TradeDay < startTradeday).Count();
//                 endIndex = startIndex + (uint)result.Count - 1;
//            }

//            return result;
//        }

//        /// <summary>
//        /// 查询单代码指定起、止序号的所有分线数据
//        /// </summary>
//        /// <param name="code">证券代码</param>
//        /// <param name="startIndex">起始序号, 查询成功是，返回结果中第一条记录在全部数据中的序号(按日编序号)</param>
//        /// <param name="endIndex">结束序号, 查询成功是，返回结果中最后一条记录在全部数据中的序号(按日编序号)</param>
//        /// <returns></returns>
//        public List<StockMinuteData> GetDatasByIndex(string code, ref int startIndex, ref int endIndex)
//        {
//            List<StockMinuteData> result = new List<StockMinuteData>();

//            if (!_Collections.ContainsKey(this.Source))
//                return result;

//            if (string.IsNullOrEmpty(code))
//                return result;

//            // 检查序号是否有效
//            if (startIndex >= 0 && startIndex > endIndex)
//                return result;
//            else if (startIndex < 0 && startIndex < endIndex)
//                return result;

//            int totalcount = _Collections[this.Source].AsQueryable<StockMinuteData>()
//                .Where(x => x.Code.Equals(code)).Count();

//            // 如果是倒序，则转换成正序
//            if (startIndex < 0)
//            {
//                int expectedCount = (int)Math.Abs(startIndex - endIndex + 1);
//                startIndex = totalcount + endIndex;
//                if (startIndex < 0)
//                    startIndex = 0;
//                endIndex = startIndex + expectedCount - 1;
//                if (endIndex >= totalcount)
//                    endIndex = totalcount - 1;
//            }
//            else
//            {
//                if (startIndex >= totalcount)
//                    return result;
//                if (endIndex >= totalcount)
//                    endIndex = totalcount - 1;
//            }

//            // 查询数据
//            int skipCount = startIndex;
//            int takeCount = endIndex - startIndex + 1;
//            var minuteDatas = _Collections[this.Source].AsQueryable<StockMinuteData>()
//                                .Where(x => x.Code.Equals(code))
//                                .OrderBy(x => x.TradeDay)
//                                .Skip(skipCount)
//                                .Take(takeCount);

//            foreach (var minutedata in minuteDatas)
//                result.Add(minutedata);

//            return result;
//        }

//        /// <summary>
//        /// 取分线的总数
//        /// </summary>
//        /// <param name="code"></param>
//        /// <returns></returns>
//        public int GetTotalCount(string code)
//        {
//            return _Collections[this.Source].AsQueryable<StockMinuteData>().Where(x => x.Code.Equals(code)).Count();
//        }

//        /// <summary>
//        /// 取分线数据
//        /// </summary>
//        /// <param name="startTradeday">起始交易日</param>
//        /// <param name="endTradeday">截止交易日</param>
//        /// <param name="codesFilter">过滤代码集合</param>
//        /// <returns>如果查找到数据，则返回结果集，否则返回空结果集</returns>
//        public Dictionary<string, List<StockMinuteData>> GetDatasByTradeDay(uint startTradeday, uint endTradeday, List<string> codesFilter)
//        {
//            Dictionary<string, List<StockMinuteData>> retValues = new Dictionary<string, List<StockMinuteData>>();

//            // 查询结果数据
//            var dailyDatas = _Collections[this.Source].AsQueryable<StockMinuteData>()
//                .Where(x => codesFilter.Contains(x.Code) && x.TradeDay >= startTradeday && x.TradeDay <= endTradeday);

//            // 处理结果集
//            if (dailyDatas != null && dailyDatas.Count() > 0)
//            {
//                foreach (var dailydata in dailyDatas)
//                {
//                    if (!retValues.ContainsKey(dailydata.Code))
//                        retValues[dailydata.Code] = new List<StockMinuteData>();
//                    retValues[dailydata.Code].Add(dailydata);
//                }
//            }

//            return retValues;
//        }

//        /// <summary>
//        /// 查询给定交易日在数据中的序号
//        /// </summary>
//        /// <param name="code"></param>
//        /// <param name="tradeday"></param>
//        /// <returns>
//        ///             如果入参错误，则返回Int32.MinValue，
//        ///             如果给定交易日早于第一条数据，则返回-1，
//        ///             其它，则返回序号（实际按小于给定交易日的数据记录条数的汇总数）
//        /// </returns>
//        public int GetSequenceNoOfTradeday(string code, uint tradeday)
//        {
//            if (!_Collections.ContainsKey(this.Source))
//                return Int32.MinValue;

//            if (string.IsNullOrEmpty(code))
//                return Int32.MinValue;

//            var data = GetDatasByTradeDay(code, tradeday);
//            int count = _Collections[this.Source].AsQueryable<StockMinuteData>()
//                .Where(x => x.Code.Equals(code) && x.TradeDay < tradeday).Count();

//            if (count == 0)
//                return data == null ? -1 : 0;
//            return count;
//        }

//    }

//    #endregion

//    #region 期货行情归档集合类

//    /// <summary>
//    /// 基本信息归档集合
//    /// </summary>
//    internal class FutureBasicInfoArchiverCollection : QuotationArchiverCollection
//    {
//        /// <summary>
//        /// 数据集合
//        /// </summary>
//        private MongoCollection _Collection = null;

//        /// <summary>
//        /// 构造器
//        /// </summary>
//        /// <param name="source"></param>
//        /// <param name="client"></param>
//        [DebuggerNonUserCode]
//        public FutureBasicInfoArchiverCollection(QuotationSource source, MongoClient client)
//            : base(source, client)
//        {
//            _Collection = GetCollection<FutureBasicInfo>(QuotationArchiverType.BasicInfo);
//            if (_Collection == null)
//                throw new Exception(string.Format("初始化数据集合失败，Source:{0}", source));
//        }

//        /// <summary>
//        /// 将基本信息归档
//        /// </summary>
//        /// <param name="basicInfo"></param>
//        /// <returns></returns>
//        public bool Archive(FutureBasicInfo basicInfo)
//        {
//            if (_Collection == null)
//                return false;
//            IMongoQuery query = Query.And(
//                    Query.EQ("Code", basicInfo.Code),
//                    Query.EQ("TradeDay", basicInfo.TradeDay));

//            WriteConcernResult result = null;
//            var preValue = _Collection.FindOneAs<FutureBasicInfo>(query);
//            if (preValue != null)
//            {
//                basicInfo._id = preValue._id;
//                IMongoUpdate update = Update.Replace(basicInfo);
//                result = _Collection.Update(query, update, UpdateFlags.Upsert);
//            }
//            else
//            {
//                result = _Collection.Insert(basicInfo);
//            }
//            return result.Ok;
//        }

//        /// <summary>
//        /// 查询单代码指定交易日的基本资料
//        /// </summary>
//        /// <param name="code">证券代码</param>
//        /// <param name="tradeday">交易日</param>
//        /// <returns></returns>
//        public FutureBasicInfo GetDatasByTradeDay(string code, uint tradeday)
//        {
//            if (string.IsNullOrEmpty(code) || _Collection == null)
//                return null;

//            return _Collection.AsQueryable<FutureBasicInfo>()
//                .Where(x => x.TradeDay == tradeday && x.Code.Equals(code)).FirstOrDefault();
//        }
//        /// <summary>
//        /// 查询指定交易日的基本资料集合
//        /// </summary>
//        /// <param name="tradeDay"></param>
//        /// <returns></returns>
//        public  List<FutureBasicInfo> GetBasicInfosByTradeDay(uint tradeDay)
//        {
//            if ( _Collection == null)
//                return null;

//            return _Collection.AsQueryable<FutureBasicInfo>()
//                .Where(x => x.TradeDay == tradeDay).ToList();
//        }
//    }

//    /// <summary>
//    /// 基本信息归档集合
//    /// </summary>
//    internal class FutureQuotationInfoArchiverCollection : QuotationArchiverCollection
//    {
//        /// <summary>
//        /// 数据集合
//        /// </summary>
//        private MongoCollection _Collection = null;

//        /// <summary>
//        /// 构造器
//        /// </summary>
//        /// <param name="source"></param>
//        /// <param name="client"></param>
//        [DebuggerNonUserCode]
//        public FutureQuotationInfoArchiverCollection(QuotationSource source, MongoClient client)
//            : base(source, client)
//        {
//            _Collection = GetCollection<FutureQuotationInfo>(QuotationArchiverType.QuotationInfo);
//            if (_Collection == null)
//                throw new Exception(string.Format("初始化数据集合失败，Source:{0}", source));
//        }

//        /// <summary>
//        /// 将基本信息归档
//        /// </summary>
//        /// <param name="quotationInfo"></param>
//        /// <returns></returns>
//        public bool Archive(FutureQuotationInfo quotationInfo)
//        {
//            if (_Collection == null)
//                return false;
//            IMongoQuery query = Query.And(
//                 Query.EQ("Code", quotationInfo.Code),
//                 Query.EQ("TradeDay", quotationInfo.TradeDay));

//            WriteConcernResult result = null;
//            var preValue = _Collection.FindOneAs<FutureQuotationInfo>(query);
//            if (preValue != null)
//            {
//                quotationInfo._id = preValue._id;
//                IMongoUpdate update = Update.Replace(quotationInfo);
//                result = _Collection.Update(query, update, UpdateFlags.Upsert);
//            }
//            else
//            {
//                result = _Collection.Insert(quotationInfo);
//            }
//            return result.Ok;
//        }

//        /// <summary>
//        /// 查询单代码指定交易日的行情资料
//        /// </summary>
//        /// <param name="code">证券代码</param>
//        /// <param name="tradeday">交易日</param>
//        /// <returns></returns>
//        public FutureQuotationInfo GetDatasByTradeDay(string code, uint tradeday)
//        {
//            if (string.IsNullOrEmpty(code) || _Collection == null)
//                return null;

//            return _Collection.AsQueryable<FutureQuotationInfo>()
//                .Where(x => x.TradeDay == tradeday && x.Code.Equals(code)).FirstOrDefault();
//        }
//        /// <summary>
//        /// 查询指定交易日的行情资料集合
//        /// </summary>
//        /// <param name="tradeDay">交易日</param>
//        /// <returns></returns>
//        public List<FutureQuotationInfo> GetQuotInfosByTradeDay(uint tradeDay)
//        {
//            if (_Collection == null)
//                return null;

//            return _Collection.AsQueryable<FutureQuotationInfo>()
//                .Where(x => x.TradeDay == tradeDay ).ToList();
//        }
//    }

//    /// <summary>
//    /// 逐笔信息归档集合
//    /// </summary>
//    internal class FutureTickInfoArchiverCollection : QuotationArchiverCollection
//    {
//        /// <summary>
//        /// 数据集合
//        /// </summary>
//        private MongoCollection _Collection = null;

//        /// <summary>
//        /// 构造器
//        /// </summary>
//        /// <param name="source"></param>
//        /// <param name="client"></param>
//        [DebuggerNonUserCode]
//        public FutureTickInfoArchiverCollection(QuotationSource source, MongoClient client)
//            : base(source, client)
//        {
//            _Collection = GetCollection<FutureTickInfo>(QuotationArchiverType.TickInfo);
//            if (_Collection == null)
//                throw new Exception(string.Format("初始化数据集合失败，Source:{0}", source));
//        }

//        /// <summary>
//        /// 将逐笔信息归档
//        /// </summary>
//        /// <param name="tickInfo"></param>
//        /// <returns></returns>
//        public bool Archive(FutureTickInfo tickInfo)
//        {
//            if (_Collection == null)
//                return false;
//            IMongoQuery query = Query.And(
//     Query.EQ("Code", tickInfo.Code),
//     Query.EQ("TradeDay", tickInfo.TradeDay),
//      Query.EQ("Sequence", tickInfo.Sequence));

//            WriteConcernResult result = null;
//            var preValue = _Collection.FindOneAs<FutureTickInfo>(query);
//            if (preValue != null)
//            {
//                tickInfo._id = preValue._id;
//                IMongoUpdate update = Update.Replace(tickInfo);
//                result = _Collection.Update(query, update, UpdateFlags.Upsert);
//            }
//            else
//            {
//                result = _Collection.Insert(tickInfo);
//            }
//            return result.Ok;
//        }

//        /// <summary>
//        /// 查询单代码指定交易日的Tick资料
//        /// </summary>
//        /// <param name="code">证券代码</param>
//        /// <param name="tradeday">交易日</param>
//        /// <returns></returns>
//        public List<FutureTickInfo> GetTicksByTradeDay(string code, uint tradeday)
//        {
//            if (string.IsNullOrEmpty(code) || _Collection == null)
//                return null;

//            return _Collection.AsQueryable<FutureTickInfo>()
//                .Where(x => x.TradeDay == tradeday && x.Code.Equals(code)).ToList();
//        }
//    }

//    /// <summary>
//    /// 日线数据归档集合
//    /// </summary>
//    internal class FutureDailyDataArchiverCollection : QuotationArchiverCollection
//    {
//        /// <summary>
//        /// 数据集合
//        /// </summary>
//        private MongoCollection _Collection = null;

//        /// <summary>
//        /// 构造器
//        /// </summary>
//        /// <param name="source"></param>
//        /// <param name="client"></param>
//        [DebuggerNonUserCode]
//        public FutureDailyDataArchiverCollection(QuotationSource source, MongoClient client)
//            : base(source, client)
//        {
//            _Collection = GetCollection<FutureDailyData>(QuotationArchiverType.DailyData);
//            if (_Collection == null)
//                throw new Exception(string.Format("初始化数据集合失败，Source:{0}", source));
//        }

//        /// <summary>
//        /// 将日线数据归档
//        /// </summary>
//        /// <param name="dailyData"></param>
//        /// <returns></returns>
//        public bool Archive(FutureDailyData dailyData)
//        {
//            if (_Collection == null)
//                return false;
//            IMongoQuery query = Query.And(
//Query.EQ("Code", dailyData.Code),
//Query.EQ("TradeDay", dailyData.TradeDay));


//            WriteConcernResult result = null;
//            var preValue = _Collection.FindOneAs<FutureDailyData>(query);
//            if (preValue != null)
//            {
//                dailyData._id = preValue._id;
//                IMongoUpdate update = Update.Replace(dailyData);
//                result = _Collection.Update(query, update, UpdateFlags.Upsert);
//            }
//            else
//            {
//                result = _Collection.Insert(dailyData);
//            }
//            return result.Ok;
//        }

//        /// <summary>
//        /// 查询单代码指定交易日的所有日线数据
//        /// </summary>
//        /// <param name="code">证券代码</param>
//        /// <param name="tradeday">交易日</param>
//        /// <returns></returns>
//        public FutureDailyData GetDatasByTradeDay(string code, uint tradeday)
//        {
//            if (string.IsNullOrEmpty(code) || _Collection == null)
//                return null;

//            return _Collection.AsQueryable<FutureDailyData>()
//                .Where(x => x.TradeDay == tradeday && x.Code.Equals(code)).FirstOrDefault();
//        }

//        /// <summary>
//        /// 查询单代码指定交易日范围内的所有日线数据
//        /// </summary>
//        /// <param name="code">证券代码</param>
//        /// <param name="startTradeday">起始交易日, 查询成功是，返回结果中第一条记录在全部数据中的序号(按日编序号)</param>
//        /// <param name="endTradeday">结束交易日, 查询成功是，返回结果中最后一条记录在全部数据中的序号(按日编序号)</param>
//        /// <returns></returns>
//        public List<FutureDailyData> GetDatasByTradeDay(string code, ref uint startTradeday, ref uint endTradeday)
//        {
//            List<FutureDailyData> result = new List<FutureDailyData>();
//            if (string.IsNullOrEmpty(code) || _Collection == null)
//                return result;

//            uint start = startTradeday;
//            uint end = endTradeday;

//            // 查询结果数据
//            var dailyDatas = _Collection.AsQueryable<FutureDailyData>().Where(x => x.TradeDay >= start && x.TradeDay <= end && x.Code.Equals(code));
//            foreach (var dailydata in dailyDatas)
//                result.Add(dailydata);

//            // 如果数据不为空，则查询起始序号
//            if (result.Count != 0)
//            {
//                int startIndex = _Collection.AsQueryable<FutureDailyData>()
//                    .Where(x => x.Code.Equals(code) && x.TradeDay < start).Count();

//                startTradeday = (uint)startIndex;
//                endTradeday = startTradeday + (uint)result.Count - 1;
//            }

//            return result;
//        }

//        /// <summary>
//        /// 查询单代码指定起、止序号的所有日线数据
//        /// </summary>
//        /// <param name="code">证券代码</param>
//        /// <param name="startIndex">起始序号, 查询成功是，返回结果中第一条记录在全部数据中的序号(按日编序号)</param>
//        /// <param name="endIndex">结束序号, 查询成功是，返回结果中最后一条记录在全部数据中的序号(按日编序号)</param>
//        /// <returns></returns>
//        public List<FutureDailyData> GetDatasByIndex(string code, ref int startIndex, ref int endIndex)
//        {
//            List<FutureDailyData> result = new List<FutureDailyData>();
//            if (string.IsNullOrEmpty(code) || _Collection == null)
//                return result;

//            // 检查序号是否有效
//            if (startIndex >= 0 && startIndex > endIndex)
//                return result;
//            else if (startIndex < 0 && startIndex < endIndex)
//                return result;

//            int totalcount = _Collection.AsQueryable<FutureDailyData>()
//                .Where(x => x.Code.Equals(code)).Count();


//            // 如果是倒序，则转换成正序
//            if (startIndex < 0)
//            {
//                int expectedCount = (int)Math.Abs(startIndex - endIndex + 1);
//                startIndex = totalcount + endIndex;
//                if (startIndex < 0)
//                    startIndex = 0;
//                endIndex = startIndex + expectedCount - 1;
//                if (endIndex >= totalcount)
//                    endIndex = totalcount - 1;
//            }
//            else
//            {
//                if (startIndex >= totalcount)
//                    return result;
//                if (endIndex >= totalcount)
//                    endIndex = totalcount - 1;
//            }

//            // 查询数据
//            int skipCount = startIndex;
//            int takeCount = endIndex - startIndex + 1;
//            var minuteDatas = _Collection.AsQueryable<FutureDailyData>()
//                                .Where(x => x.Code.Equals(code))
//                                .OrderBy(x => x.TradeDay)
//                                .Skip(skipCount)
//                                .Take(takeCount);

//            foreach (var minutedata in minuteDatas)
//                result.Add(minutedata);

//            return result;
//        }

//        /// <summary>
//        /// 查询单代码所有日线数据
//        /// </summary>
//        /// <param name="code">证券代码</param>
//        /// <returns></returns>
//        public List<FutureDailyData> GetAllDatas(string code)
//        {
//            if (string.IsNullOrEmpty(code))
//                return new List<FutureDailyData>();

//            // 查询结果数据
//            return _Collection.AsQueryable<FutureDailyData>().Where(x => x.Code.Equals(code)).ToList();
//        }

//        /// <summary>
//        /// 取日线的总数
//        /// </summary>
//        /// <param name="code"></param>
//        /// <returns></returns>
//        public int GetTotalCount(string code)
//        {
//            return _Collection.AsQueryable<FutureDailyData>().Where(x => x.Code.Equals(code)).Count();
//        }

//        /// <summary>
//        /// 查询给定交易日在数据中的序号
//        /// </summary>
//        /// <param name="code"></param>
//        /// <param name="tradeday"></param>
//        /// <returns>
//        ///             如果入参错误，则返回Int32.MinValue，
//        ///             如果给定交易日早于第一条数据，则返回-1，
//        ///             其它，则返回序号（实际按小于给定交易日的数据记录条数的汇总数）
//        /// </returns>
//        public int GetSequenceNoOfTradeday(string code, uint tradeday)
//        {
//            if (string.IsNullOrEmpty(code))
//                return Int32.MinValue;

//            var data = GetDatasByTradeDay(code, tradeday);
//            int count = _Collection.AsQueryable<FutureDailyData>()
//                .Where(x => x.Code.Equals(code) && x.TradeDay < tradeday).Count();

//            if (count == 0)
//                return data == null ? -1 : 0;
//            return count;
//        }

//    }

//    /// <summary>
//    /// 分线数据归档集合
//    /// </summary>
//    internal class FutureMinuteDataArchiverCollection : QuotationArchiverCollection
//    {
//        /// <summary>
//        /// 数据集合
//        /// </summary>
//        private MongoCollection _Collection = null;

//        /// <summary>
//        /// 构造器
//        /// </summary>
//        /// <param name="source"></param>
//        /// <param name="client"></param>
//        [DebuggerNonUserCode]
//        public FutureMinuteDataArchiverCollection(QuotationSource source, MongoClient client)
//            : base(source, client)
//        {
//            _Collection = GetCollection<FutureMinuteData>(QuotationArchiverType.MinuteData);
//            if (_Collection == null)
//                throw new Exception(string.Format("初始化数据集合失败，Source:{0}", source));
//        }

//        /// <summary>
//        /// 将分线数据归档
//        /// </summary>
//        /// <param name="minuteData"></param>
//        /// <returns></returns>
//        public bool Archive(FutureMinuteData minuteData)
//        {
//            if (_Collection == null)
//                return false;
//            IMongoQuery query = Query.And(
//Query.EQ("Code", minuteData.Code),
//Query.EQ("TradeDay", minuteData.TradeDay));

//            WriteConcernResult result = null;
//            var preValue = _Collection.FindOneAs<FutureMinuteData>(query);
//            if (preValue != null)
//            {
//                minuteData._id = preValue._id;
//                IMongoUpdate update = Update.Replace(minuteData);
//                result = _Collection.Update(query, update, UpdateFlags.Upsert);
//            }
//            else
//            {
//                result = _Collection.Insert(minuteData);
//            }
//            return result.Ok;
//        }

//        /// <summary>
//        /// 查询单代码指定交易日的所有分线数据
//        /// </summary>
//        /// <param name="code">证券代码</param>
//        /// <param name="tradeday">交易日</param>
//        /// <returns></returns>
//        public FutureMinuteData GetDatasByTradeDay(string code, uint tradeday)
//        {
//            if (string.IsNullOrEmpty(code) || _Collection == null)
//                return null;

//            return _Collection.AsQueryable<FutureMinuteData>()
//                    .Where(x => x.TradeDay == tradeday && x.Code.Equals(code)).FirstOrDefault();
//        }

//        /// <summary>
//        /// 查询单代码指定交易日的所有分线数据
//        /// </summary>
//        /// <param name="code">证券代码</param>
//        /// <param name="startTradeday">起始交易日, 查询成功是，返回结果中第一条记录在全部数据中的序号(按日编序号)</param>
//        /// <param name="endTradeday">结束交易日, 查询成功是，返回结果中最后一条记录在全部数据中的序号(按日编序号)</param>
//        /// <returns></returns>
//        public List<FutureMinuteData> GetDatasByTradeDay(string code, ref uint startTradeday, ref uint endTradeday)
//        {
//            List<FutureMinuteData> result = new List<FutureMinuteData>();
//            if (string.IsNullOrEmpty(code) || _Collection == null)
//                return result;

//            uint start = startTradeday;
//            uint end = endTradeday;

//            // 查询结果数据
//            var minuteDatas = _Collection.AsQueryable<FutureMinuteData>()
//                .Where(x => x.TradeDay >= start && x.TradeDay <= end && x.Code.Equals(code));

//            foreach (var minutedata in minuteDatas)
//                result.Add(minutedata);

//            // 如果数据不为空，则查询起始序号
//            if (result.Count != 0)
//            {
//                int startIndex = _Collection.AsQueryable<FutureMinuteData>()
//                    .Where(x => x.Code.Equals(code) && x.TradeDay < start).Count();

//                startTradeday = (uint)startIndex;
//                endTradeday = startTradeday + (uint)result.Count - 1;
//            }

//            return result;
//        }

//        /// <summary>
//        /// 查询单代码指定起、止序号的所有日线数据
//        /// </summary>
//        /// <param name="code">证券代码</param>
//        /// <param name="startIndex">起始序号, 查询成功是，返回结果中第一条记录在全部数据中的序号(按日编序号)</param>
//        /// <param name="endIndex">结束序号, 查询成功是，返回结果中最后一条记录在全部数据中的序号(按日编序号)</param>
//        /// <returns></returns>
//        public List<FutureMinuteData> GetDatasByIndex(string code, ref int startIndex, ref int endIndex)
//        {
//            List<FutureMinuteData> result = new List<FutureMinuteData>();
//            if (string.IsNullOrEmpty(code) || _Collection == null)
//                return result;

//            // 检查序号是否有效
//            if (startIndex >= 0 && startIndex > endIndex)
//                return result;
//            else if (startIndex < 0 && startIndex < endIndex)
//                return result;

//            int totalcount = _Collection.AsQueryable<FutureMinuteData>()
//                .Where(x => x.Code.Equals(code)).Count();

//            // 如果是倒序，则转换成正序
//            if (startIndex < 0)
//            {
//                int expectedCount = (int)Math.Abs(startIndex - endIndex + 1);
//                startIndex = totalcount + endIndex;
//                if (startIndex < 0)
//                    startIndex = 0;
//                endIndex = startIndex + expectedCount - 1;
//                if (endIndex >= totalcount)
//                    endIndex = totalcount - 1;
//            }
//            else
//            {
//                if (startIndex >= totalcount)
//                    return result;
//                if (endIndex >= totalcount)
//                    endIndex = totalcount - 1;
//            }

//            // 查询数据
//            int skipCount = startIndex;
//            int takeCount = endIndex - startIndex + 1;
//            var minuteDatas = _Collection.AsQueryable<FutureMinuteData>()
//                                .Where(x => x.Code.Equals(code))
//                                .OrderBy(x => x.TradeDay)
//                                .Skip(skipCount)
//                                .Take(takeCount);

//            foreach (var minutedata in minuteDatas)
//                result.Add(minutedata);

//            return result;
//        }

//        /// <summary>
//        /// 取分线的总数
//        /// </summary>
//        /// <param name="code"></param>
//        /// <returns></returns>
//        public int GetTotalCount(string code)
//        {
//            return _Collection.AsQueryable<FutureMinuteData>().Where(x => x.Code.Equals(code)).Count();
//        }

//        /// <summary>
//        /// 查询给定交易日在数据中的序号
//        /// </summary>
//        /// <param name="code"></param>
//        /// <param name="tradeday"></param>
//        /// <returns>
//        ///             如果入参错误，则返回Int32.MinValue，
//        ///             如果给定交易日早于第一条数据，则返回-1，
//        ///             其它，则返回序号（实际按小于给定交易日的数据记录条数的汇总数）
//        /// </returns>
//        public int GetSequenceNoOfTradeday(string code, uint tradeday)
//        {
//            if (string.IsNullOrEmpty(code))
//                return Int32.MinValue;

//            var data = GetDatasByTradeDay(code, tradeday);
//            int count = _Collection.AsQueryable<FutureMinuteData>()
//                .Where(x => x.Code.Equals(code) && x.TradeDay < tradeday).Count();

//            if (count == 0)
//                return data == null ? -1 : 0;
//            return count;
//        }
//    }

//    #endregion

//    #region 组合行情归档集合类


//    /// <summary>
//    /// 基本信息归档集合
//    /// </summary>
//    internal class ComboBasicInfoArchiverCollection : QuotationArchiverCollection
//    {
//        /// <summary>
//        /// 数据集合
//        /// </summary>
//        private MongoCollection _Collection = null;

//        /// <summary>
//        /// 构造器
//        /// </summary>
//        /// <param name="source"></param>
//        /// <param name="client"></param>
//        [DebuggerNonUserCode]
//        public ComboBasicInfoArchiverCollection(QuotationSource source, MongoClient client)
//            : base(source, client)
//        {
//            _Collection = GetCollection<ComboBasicInfo>(QuotationArchiverType.BasicInfo);
//            if (_Collection == null)
//                throw new Exception(string.Format("初始化数据集合失败，Source:{0}", source));
//        }

//        /// <summary>
//        /// 将基本信息归档
//        /// </summary>
//        /// <param name="basicInfo"></param>
//        /// <returns></returns>
//        public bool Archive(ComboBasicInfo basicInfo)
//        {
//            if (_Collection == null)
//                return false;
//            IMongoQuery query = Query.And(
//                       Query.EQ("Code", basicInfo.Code),
//                       Query.EQ("TradeDay", basicInfo.TradeDay));

//            WriteConcernResult result = null;
//            var preValue = _Collection.FindOneAs<ComboBasicInfo>(query);
//            if (preValue != null)
//            {
//                basicInfo._id = preValue._id;
//                IMongoUpdate update = Update.Replace(basicInfo);
//                result = _Collection.Update(query, update, UpdateFlags.Upsert);
//            }
//            else
//            {
//                result = _Collection.Insert(basicInfo);
//            }

//            return result.Ok;
//        }

//        /// <summary>
//        /// 查询单代码指定交易日的基本资料
//        /// </summary>
//        /// <param name="code">证券代码</param>
//        /// <param name="tradeday">交易日</param>
//        /// <returns></returns>
//        public ComboBasicInfo GetBasicInfoByTradeDay(string code, uint tradeday)
//        {
//            if (string.IsNullOrEmpty(code) || _Collection == null)
//                return null;

//            return _Collection.AsQueryable<ComboBasicInfo>()
//                .Where(x => x.TradeDay == tradeday && x.Code.Equals(code)).FirstOrDefault();
//        }

//        /// <summary>
//        /// 取指定交易日的所有基本资料
//        /// </summary>
//        /// <param name="tradeDay"></param>
//        /// <returns></returns>
//        public List<ComboBasicInfo> GetBasicInfosByTradeDay(uint tradeDay)
//        {
//            if (_Collection == null)
//                return null;
//            return _Collection.AsQueryable<ComboBasicInfo>()
//             .Where(x => x.TradeDay == tradeDay).ToList();
//        }
//    }



//    /// <summary>
//    /// 基本信息归档集合
//    /// </summary>
//    internal class ComboQuotationInfoArchiverCollection : QuotationArchiverCollection
//    {
//        /// <summary>
//        /// 数据集合
//        /// </summary>
//        private MongoCollection _Collection = null;

//        /// <summary>
//        /// 构造器
//        /// </summary>
//        /// <param name="source"></param>
//        /// <param name="client"></param>
//        [DebuggerNonUserCode]
//        public ComboQuotationInfoArchiverCollection(QuotationSource source, MongoClient client)
//            : base(source, client)
//        {
//            _Collection = GetCollection<ComboQuotationInfo>(QuotationArchiverType.QuotationInfo);
//            if (_Collection == null)
//                throw new Exception(string.Format("初始化数据集合失败，Source:{0}", source));
//        }

//        /// <summary>
//        /// 将基本信息归档
//        /// </summary>
//        /// <param name="quotationInfo"></param>
//        /// <returns></returns>
//        public bool Archive(ComboQuotationInfo quotationInfo)
//        {
//            if (_Collection == null)
//                return false;
//            IMongoQuery query = Query.And(
//Query.EQ("Code", quotationInfo.Code),
//Query.EQ("TradeDay", quotationInfo.TradeDay));

//            WriteConcernResult result = null;
//            var preValue = _Collection.FindOneAs<ComboQuotationInfo>(query);
//            if (preValue != null)
//            {
//                quotationInfo._id = preValue._id;
//                IMongoUpdate update = Update.Replace(quotationInfo);
//                result = _Collection.Update(query, update, UpdateFlags.Upsert);
//            }
//            else
//            {
//                result = _Collection.Insert(quotationInfo);
//            }
//            return result.Ok;
//        }

//        /// <summary>
//        /// 查询单代码指定交易日的行情资料
//        /// </summary>
//        /// <param name="code">证券代码</param>
//        /// <param name="tradeday">交易日</param>
//        /// <returns></returns>
//        public ComboQuotationInfo GetDatasByTradeDay(string code, uint tradeday)
//        {
//            if (string.IsNullOrEmpty(code) || _Collection == null)
//                return null;

//            return _Collection.AsQueryable<ComboQuotationInfo>()
//                .Where(x => x.TradeDay == tradeday && x.Code.Equals(code)).FirstOrDefault();
//        }

//        /// <summary>
//        /// 查询指定交易日的行情资料
//        /// </summary>
//        /// <param name="tradeDay"></param>
//        /// <returns></returns>
//        internal List<ComboQuotationInfo> GetQuotInfosByTradeDay(uint tradeDay)
//        {
//            if (_Collection == null)
//                return null;

//            return _Collection.AsQueryable<ComboQuotationInfo>()
//                .Where(x => x.TradeDay == tradeDay).ToList();
//        }
//    }

//    /// <summary>
//    /// 逐笔信息归档集合
//    /// </summary>
//    internal class ComboTickInfoArchiverCollection : QuotationArchiverCollection
//    {
//        /// <summary>
//        /// 数据集合
//        /// </summary>
//        private MongoCollection _Collection = null;

//        /// <summary>
//        /// 构造器
//        /// </summary>
//        /// <param name="source"></param>
//        /// <param name="client"></param>
//        [DebuggerNonUserCode]
//        public ComboTickInfoArchiverCollection(QuotationSource source, MongoClient client)
//            : base(source, client)
//        {
//            _Collection = GetCollection<ComboTickInfo>(QuotationArchiverType.TickInfo);
//            if (_Collection == null)
//                throw new Exception(string.Format("初始化数据集合失败，Source:{0}", source));
//        }

//        /// <summary>
//        /// 将逐笔信息归档
//        /// </summary>
//        /// <param name="tickInfo"></param>
//        /// <returns></returns>
//        public bool Archive(ComboTickInfo tickInfo)
//        {
//            if (_Collection == null)
//                return false;

//            IMongoQuery query = Query.And(
//  Query.EQ("Code", tickInfo.Code),
//  Query.EQ("TradeDay", tickInfo.TradeDay),
//   Query.EQ("Sequence", tickInfo.Sequence));

//            WriteConcernResult result = null;
//            var preValue = _Collection.FindOneAs<ComboTickInfo>(query);
//            if (preValue != null)
//            {
//                tickInfo._id = preValue._id;
//                IMongoUpdate update = Update.Replace(tickInfo);
//                result = _Collection.Update(query, update, UpdateFlags.Upsert);
//            }
//            else
//            {
//                result = _Collection.Insert(tickInfo);
//            }
//            return result.Ok;
//        }

//        /// <summary>
//        /// 查询单代码指定交易日的Tick资料
//        /// </summary>
//        /// <param name="code">证券代码</param>
//        /// <param name="tradeday">交易日</param>
//        /// <returns></returns>
//        public List<ComboTickInfo> GetTicksByTradeDay(string code, uint tradeday)
//        {
//            if (string.IsNullOrEmpty(code) || _Collection == null)
//                return null;

//            return _Collection.AsQueryable<ComboTickInfo>()
//                .Where(x => x.TradeDay == tradeday && x.Code.Equals(code)).ToList();
//        }
//    }

//    /// <summary>
//    /// 日线数据归档集合
//    /// </summary>
//    internal class ComboDailyDataArchiverCollection : QuotationArchiverCollection
//    {
//        /// <summary>
//        /// 数据集合
//        /// </summary>
//        private MongoCollection _Collection = null;

//        /// <summary>
//        /// 构造器
//        /// </summary>
//        /// <param name="source"></param>
//        /// <param name="client"></param>
//        [DebuggerNonUserCode]
//        public ComboDailyDataArchiverCollection(QuotationSource source, MongoClient client)
//            : base(source, client)
//        {
//            _Collection = GetCollection<ComboDailyData>(QuotationArchiverType.DailyData);
//            if (_Collection == null)
//                throw new Exception(string.Format("初始化数据集合失败，Source:{0}", source));
//        }

//        /// <summary>
//        /// 将日线数据归档
//        /// </summary>
//        /// <param name="dailyData"></param>
//        /// <returns></returns>
//        public bool Archive(ComboDailyData dailyData)
//        {
//            if (_Collection == null)
//                return false;

//            IMongoQuery query = Query.And(
//  Query.EQ("Code", dailyData.Code),
//  Query.EQ("TradeDay", dailyData.TradeDay));

//            WriteConcernResult result = null;
//            var preValue = _Collection.FindOneAs<ComboDailyData>(query);
//            if (preValue != null)
//            {
//                dailyData._id = preValue._id;
//                IMongoUpdate update = Update.Replace(dailyData);
//                result = _Collection.Update(query, update, UpdateFlags.Upsert);
//            }
//            else
//            {
//                result = _Collection.Insert(dailyData);
//            }
//            return result.Ok;
//        }

//        /// <summary>
//        /// 查询单代码指定交易日的所有日线数据
//        /// </summary>
//        /// <param name="code">证券代码</param>
//        /// <param name="tradeday">交易日</param>
//        /// <returns></returns>
//        public ComboDailyData GetDatasByTradeDay(string code, uint tradeday)
//        {
//            if (string.IsNullOrEmpty(code) || _Collection == null)
//                return null;

//            return _Collection.AsQueryable<ComboDailyData>()
//                .Where(x => x.TradeDay == tradeday && x.Code.Equals(code)).FirstOrDefault();
//        }

//        /// <summary>
//        /// 查询单代码指定交易日范围内的所有日线数据
//        /// </summary>
//        /// <param name="code">证券代码</param>
//        /// <param name="startTradeday">起始交易日, 查询成功是，返回结果中第一条记录在全部数据中的序号(按日编序号)</param>
//        /// <param name="endTradeday">结束交易日, 查询成功是，返回结果中最后一条记录在全部数据中的序号(按日编序号)</param>
//        /// <returns></returns>
//        public List<ComboDailyData> GetDatasByTradeDay(string code, ref uint startTradeday, ref uint endTradeday)
//        {
//            List<ComboDailyData> result = new List<ComboDailyData>();
//            if (string.IsNullOrEmpty(code) || _Collection == null)
//                return result;

//            uint start = startTradeday;
//            uint end = endTradeday;

//            // 查询结果数据
//            var dailyDatas = _Collection.AsQueryable<ComboDailyData>().Where(x => x.TradeDay >= start && x.TradeDay <= end && x.Code.Equals(code));
//            foreach (var dailydata in dailyDatas)
//                result.Add(dailydata);

//            // 如果数据不为空，则查询起始序号
//            if (result.Count != 0)
//            {
//                int startIndex = _Collection.AsQueryable<ComboDailyData>()
//                    .Where(x => x.Code.Equals(code) && x.TradeDay < start).Count();

//                startTradeday = (uint)startIndex;
//                endTradeday = startTradeday + (uint)result.Count - 1;
//            }

//            return result;
//        }

//        /// <summary>
//        /// 查询单代码指定起、止序号的所有日线数据
//        /// </summary>
//        /// <param name="code">证券代码</param>
//        /// <param name="startIndex">起始序号, 查询成功是，返回结果中第一条记录在全部数据中的序号(按日编序号)</param>
//        /// <param name="endIndex">结束序号, 查询成功是，返回结果中最后一条记录在全部数据中的序号(按日编序号)</param>
//        /// <returns></returns>
//        public List<ComboDailyData> GetDatasByIndex(string code, ref int startIndex, ref int endIndex)
//        {
//            List<ComboDailyData> result = new List<ComboDailyData>();
//            if (string.IsNullOrEmpty(code) || _Collection == null)
//                return result;

//            // 检查序号是否有效
//            if (startIndex >= 0 && startIndex > endIndex)
//                return result;
//            else if (startIndex < 0 && startIndex < endIndex)
//                return result;

//            int totalcount = _Collection.AsQueryable<ComboDailyData>()
//                .Where(x => x.Code.Equals(code)).Count();

//            // 如果是倒序，则转换成正序
//            if (startIndex < 0)
//            {
//                int expectedCount = (int)Math.Abs(startIndex - endIndex + 1);
//                startIndex = totalcount + endIndex;
//                if (startIndex < 0)
//                    startIndex = 0;
//                endIndex = startIndex + expectedCount - 1;
//                if (endIndex >= totalcount)
//                    endIndex = totalcount - 1;
//            }
//            else
//            {
//                if (startIndex >= totalcount)
//                    return result;
//                if (endIndex >= totalcount)
//                    endIndex = totalcount - 1;
//            }

//            // 查询数据
//            int skipCount = startIndex;
//            int takeCount = endIndex - startIndex + 1;
//            var minuteDatas = _Collection.AsQueryable<ComboDailyData>()
//                                .Where(x => x.Code.Equals(code))
//                                .OrderBy(x => x.TradeDay)
//                                .Skip(skipCount)
//                                .Take(takeCount);

//            foreach (var minutedata in minuteDatas)
//                result.Add(minutedata);

//            return result;
//        }

//        /// <summary>
//        /// 查询单代码所有日线数据
//        /// </summary>
//        /// <param name="code">证券代码</param>
//        /// <returns></returns>
//        public List<ComboDailyData> GetAllDatas(string code)
//        {
//            if (string.IsNullOrEmpty(code))
//                return new List<ComboDailyData>();

//            // 查询结果数据
//            return _Collection.AsQueryable<ComboDailyData>().Where(x => x.Code.Equals(code)).ToList();
//        }

//        /// <summary>
//        /// 取日线的总数
//        /// </summary>
//        /// <param name="code"></param>
//        /// <returns></returns>
//        public int GetTotalCount(string code)
//        {
//            return _Collection.AsQueryable<ComboDailyData>().Where(x => x.Code.Equals(code)).Count();
//        }

//        /// <summary>
//        /// 查询给定交易日在数据中的序号
//        /// </summary>
//        /// <param name="code"></param>
//        /// <param name="tradeday"></param>
//        /// <returns>
//        ///             如果入参错误，则返回Int32.MinValue，
//        ///             如果给定交易日早于第一条数据，则返回-1，
//        ///             其它，则返回序号（实际按小于给定交易日的数据记录条数的汇总数）
//        /// </returns>
//        public int GetSequenceNoOfTradeday(string code, uint tradeday)
//        {
//            if (string.IsNullOrEmpty(code))
//                return Int32.MinValue;

//            var data = GetDatasByTradeDay(code, tradeday);
//            int count = _Collection.AsQueryable<ComboDailyData>()
//                .Where(x => x.Code.Equals(code) && x.TradeDay < tradeday).Count();

//            if (count == 0)
//                return data == null ? -1 : 0;
//            return count;
//        }

//    }

//    /// <summary>
//    /// 分线数据归档集合
//    /// </summary>
//    internal class ComboMinuteDataArchiverCollection : QuotationArchiverCollection
//    {
//        /// <summary>
//        /// 数据集合
//        /// </summary>
//        private MongoCollection _Collection = null;

//        /// <summary>
//        /// 构造器
//        /// </summary>
//        /// <param name="source"></param>
//        /// <param name="client"></param>
//        [DebuggerNonUserCode]
//        public ComboMinuteDataArchiverCollection(QuotationSource source, MongoClient client)
//            : base(source, client)
//        {
//            _Collection = GetCollection<ComboMinuteData>(QuotationArchiverType.MinuteData);
//            if (_Collection == null)
//                throw new Exception(string.Format("初始化数据集合失败，Source:{0}", source));
//        }

//        /// <summary>
//        /// 将分线数据归档
//        /// </summary>
//        /// <param name="minuteData"></param>
//        /// <returns></returns>
//        public bool Archive(ComboMinuteData minuteData)
//        {
//            if (_Collection == null)
//                return false;

//            IMongoQuery query = Query.And(
//Query.EQ("Code", minuteData.Code),
//Query.EQ("TradeDay", minuteData.TradeDay));

//            WriteConcernResult result = null;
//            var preValue = _Collection.FindOneAs<ComboMinuteData>(query);
//            if (preValue != null)
//            {
//                minuteData._id = preValue._id;
//                IMongoUpdate update = Update.Replace(minuteData);
//                result = _Collection.Update(query, update, UpdateFlags.Upsert);
//            }
//            else
//            {
//                result = _Collection.Insert(minuteData);
//            }
//            return result.Ok;
//        }

//        /// <summary>
//        /// 查询单代码指定交易日的所有分线数据
//        /// </summary>
//        /// <param name="code">证券代码</param>
//        /// <param name="tradeday">交易日</param>
//        /// <returns></returns>
//        public ComboMinuteData GetDatasByTradeDay(string code, uint tradeday)
//        {
//            if (string.IsNullOrEmpty(code) || _Collection == null)
//                return null;

//            return _Collection.AsQueryable<ComboMinuteData>()
//                    .Where(x => x.TradeDay == tradeday && x.Code.Equals(code)).FirstOrDefault();
//        }

//        /// <summary>
//        /// 查询单代码指定交易日的所有分线数据
//        /// </summary>
//        /// <param name="code">证券代码</param>
//        /// <param name="startTradeday">起始交易日, 查询成功是，返回结果中第一条记录在全部数据中的序号(按日编序号)</param>
//        /// <param name="endTradeday">结束交易日, 查询成功是，返回结果中最后一条记录在全部数据中的序号(按日编序号)</param>
//        /// <returns></returns>
//        public List<ComboMinuteData> GetDatasByTradeDay(string code, ref uint startTradeday, ref uint endTradeday)
//        {
//            List<ComboMinuteData> result = new List<ComboMinuteData>();
//            if (string.IsNullOrEmpty(code) || _Collection == null)
//                return result;

//            uint start = startTradeday;
//            uint end = endTradeday;

//            // 查询结果数据
//            var minuteDatas = _Collection.AsQueryable<ComboMinuteData>()
//                .Where(x => x.TradeDay >= start && x.TradeDay <= end && x.Code.Equals(code));

//            foreach (var minutedata in minuteDatas)
//                result.Add(minutedata);

//            // 如果数据不为空，则查询起始序号
//            if (result.Count != 0)
//            {
//                int startIndex = _Collection.AsQueryable<ComboMinuteData>()
//                    .Where(x => x.Code.Equals(code) && x.TradeDay < start).Count();

//                startTradeday = (uint)startIndex;
//                endTradeday = startTradeday + (uint)result.Count - 1;
//            }

//            return result;
//        }

//        /// <summary>
//        /// 查询单代码指定起、止序号的所有日线数据
//        /// </summary>
//        /// <param name="code">证券代码</param>
//        /// <param name="startIndex">起始序号, 查询成功是，返回结果中第一条记录在全部数据中的序号(按日编序号)</param>
//        /// <param name="endIndex">结束序号, 查询成功是，返回结果中最后一条记录在全部数据中的序号(按日编序号)</param>
//        /// <returns></returns>
//        public List<ComboMinuteData> GetDatasByIndex(string code, ref int startIndex, ref int endIndex)
//        {
//            List<ComboMinuteData> result = new List<ComboMinuteData>();
//            if (string.IsNullOrEmpty(code) || _Collection == null)
//                return result;

//            // 检查序号是否有效
//            if (startIndex >= 0 && startIndex > endIndex)
//                return result;
//            else if (startIndex < 0 && startIndex < endIndex)
//                return result;

//            int totalcount = _Collection.AsQueryable<ComboDailyData>()
//                .Where(x => x.Code.Equals(code)).Count();

//            // 如果是倒序，则转换成正序
//            if (startIndex < 0)
//            {
//                int expectedCount = (int)Math.Abs(startIndex - endIndex + 1);
//                startIndex = totalcount + endIndex;
//                if (startIndex < 0)
//                    startIndex = 0;
//                endIndex = startIndex + expectedCount - 1;
//                if (endIndex >= totalcount)
//                    endIndex = totalcount - 1;
//            }
//            else
//            {
//                if (startIndex >= totalcount)
//                    return result;
//                if (endIndex >= totalcount)
//                    endIndex = totalcount - 1;
//            }

//            // 查询数据
//            int skipCount = startIndex;
//            int takeCount = endIndex - startIndex + 1;
//            var minuteDatas = _Collection.AsQueryable<ComboMinuteData>()
//                                .Where(x => x.Code.Equals(code))
//                                .OrderBy(x => x.TradeDay)
//                                .Skip(skipCount)
//                                .Take(takeCount);

//            foreach (var minutedata in minuteDatas)
//                result.Add(minutedata);

//            return result;
//        }

//        /// <summary>
//        /// 取分线的总数
//        /// </summary>
//        /// <param name="code"></param>
//        /// <returns></returns>
//        public int GetTotalCount(string code)
//        {
//            return _Collection.AsQueryable<ComboMinuteData>().Where(x => x.Code.Equals(code)).Count();
//        }

//        /// <summary>
//        /// 查询给定交易日在数据中的序号
//        /// </summary>
//        /// <param name="code"></param>
//        /// <param name="tradeday"></param>
//        /// <returns>
//        ///             如果入参错误，则返回Int32.MinValue，
//        ///             如果给定交易日早于第一条数据，则返回-1，
//        ///             其它，则返回序号（实际按小于给定交易日的数据记录条数的汇总数）
//        /// </returns>
//        public int GetSequenceNoOfTradeday(string code, uint tradeday)
//        {
//            if (string.IsNullOrEmpty(code))
//                return Int32.MinValue;

//            var data = GetDatasByTradeDay(code, tradeday);
//            int count = _Collection.AsQueryable<ComboMinuteData>()
//                .Where(x => x.Code.Equals(code) && x.TradeDay < tradeday).Count();

//            if (count == 0)
//                return data == null ? -1 : 0;
//            return count;
//        }
//    }

//    #endregion




//    #region 期权行情归档集合类

//    /// <summary>
//    /// 基本信息归档集合
//    /// </summary>
//    internal class OptionBasicInfoArchiverCollection : QuotationArchiverCollection
//    {
//        /// <summary>
//        /// 数据集合
//        /// </summary>
//        private MongoCollection _Collection = null;

//        /// <summary>
//        /// 构造器
//        /// </summary>
//        /// <param name="source"></param>
//        /// <param name="client"></param>
//        [DebuggerNonUserCode]
//        public OptionBasicInfoArchiverCollection(QuotationSource source, MongoClient client)
//            : base(source, client)
//        {
//            _Collection = GetCollection<OptionBasicInfo>(QuotationArchiverType.BasicInfo);
//            if (_Collection == null)
//                throw new Exception(string.Format("初始化数据集合失败，Source:{0}", source));
//        }

//        /// <summary>
//        /// 将基本信息归档
//        /// </summary>
//        /// <param name="basicInfo"></param>
//        /// <returns></returns>
//        public bool Archive(OptionBasicInfo basicInfo)
//        {
//            if (_Collection == null)
//                return false;
//            IMongoQuery query = Query.And(
//                    Query.EQ("Code", basicInfo.Code),
//                    Query.EQ("TradeDay", basicInfo.TradeDay));

//            WriteConcernResult result = null;
//            var preValue = _Collection.FindOneAs<OptionBasicInfo>(query);
//            if (preValue != null)
//            {
//                basicInfo._id = preValue._id;
//                IMongoUpdate update = Update.Replace(basicInfo);
//                result = _Collection.Update(query, update, UpdateFlags.Upsert);
//            }
//            else
//            {
//                result = _Collection.Insert(basicInfo);
//            }
//            return result.Ok;
//        }

//        /// <summary>
//        /// 查询单代码指定交易日的基本资料
//        /// </summary>
//        /// <param name="code">证券代码</param>
//        /// <param name="tradeday">交易日</param>
//        /// <returns></returns>
//        public OptionBasicInfo GetDatasByTradeDay(string code, uint tradeday)
//        {
//            if (string.IsNullOrEmpty(code) || _Collection == null)
//                return null;

//            return _Collection.AsQueryable<OptionBasicInfo>()
//                .Where(x => x.TradeDay == tradeday && x.Code.Equals(code)).FirstOrDefault();
//        }

//        internal List<OptionBasicInfo> GetBasicInfosByTradeDay(uint tradeDay)
//        {
//            if (_Collection == null)
//                return null;

//            return _Collection.AsQueryable<OptionBasicInfo>()
//                .Where(x => x.TradeDay == tradeDay).ToList();
//        }
//    }

//    /// <summary>
//    /// 基本信息归档集合
//    /// </summary>
//    internal class OptionQuotationInfoArchiverCollection : QuotationArchiverCollection
//    {
//        /// <summary>
//        /// 数据集合
//        /// </summary>
//        private MongoCollection _Collection = null;

//        /// <summary>
//        /// 构造器
//        /// </summary>
//        /// <param name="source"></param>
//        /// <param name="client"></param>
//        [DebuggerNonUserCode]
//        public OptionQuotationInfoArchiverCollection(QuotationSource source, MongoClient client)
//            : base(source, client)
//        {
//            _Collection = GetCollection<OptionQuotationInfo>(QuotationArchiverType.QuotationInfo);
//            if (_Collection == null)
//                throw new Exception(string.Format("初始化数据集合失败，Source:{0}", source));
//        }

//        /// <summary>
//        /// 将基本信息归档
//        /// </summary>
//        /// <param name="quotationInfo"></param>
//        /// <returns></returns>
//        public bool Archive(OptionQuotationInfo quotationInfo)
//        {
//            if (_Collection == null)
//                return false;
//            IMongoQuery query = Query.And(
//                 Query.EQ("Code", quotationInfo.Code),
//                 Query.EQ("TradeDay", quotationInfo.TradeDay));

//            WriteConcernResult result = null;
//            var preValue = _Collection.FindOneAs<OptionQuotationInfo>(query);
//            if (preValue != null)
//            {
//                quotationInfo._id = preValue._id;
//                IMongoUpdate update = Update.Replace(quotationInfo);
//                result = _Collection.Update(query, update, UpdateFlags.Upsert);
//            }
//            else
//            {
//                result = _Collection.Insert(quotationInfo);
//            }
//            return result.Ok;
//        }

//        /// <summary>
//        /// 查询单代码指定交易日的行情资料
//        /// </summary>
//        /// <param name="code">证券代码</param>
//        /// <param name="tradeday">交易日</param>
//        /// <returns></returns>
//        public OptionQuotationInfo GetDatasByTradeDay(string code, uint tradeday)
//        {
//            if (string.IsNullOrEmpty(code) || _Collection == null)
//                return null;

//            return _Collection.AsQueryable<OptionQuotationInfo>()
//                .Where(x => x.TradeDay == tradeday && x.Code.Equals(code)).FirstOrDefault();
//        }

//        internal List<OptionQuotationInfo> GetQuotInfosByTradeDay(uint tradeDay)
//        {
//            if (_Collection == null)
//                return null;

//            return _Collection.AsQueryable<OptionQuotationInfo>()
//                .Where(x => x.TradeDay == tradeDay ).ToList();
//        }
//    }

//    /// <summary>
//    /// 逐笔信息归档集合
//    /// </summary>
//    internal class OptionTickInfoArchiverCollection : QuotationArchiverCollection
//    {
//        /// <summary>
//        /// 数据集合
//        /// </summary>
//        private MongoCollection _Collection = null;

//        /// <summary>
//        /// 构造器
//        /// </summary>
//        /// <param name="source"></param>
//        /// <param name="client"></param>
//        [DebuggerNonUserCode]
//        public OptionTickInfoArchiverCollection(QuotationSource source, MongoClient client)
//            : base(source, client)
//        {
//            _Collection = GetCollection<OptionTickInfo>(QuotationArchiverType.TickInfo);
//            if (_Collection == null)
//                throw new Exception(string.Format("初始化数据集合失败，Source:{0}", source));
//        }

//        /// <summary>
//        /// 将逐笔信息归档
//        /// </summary>
//        /// <param name="tickInfo"></param>
//        /// <returns></returns>
//        public bool Archive(OptionTickInfo tickInfo)
//        {
//            if (_Collection == null)
//                return false;
//            IMongoQuery query = Query.And(
//     Query.EQ("Code", tickInfo.Code),
//     Query.EQ("TradeDay", tickInfo.TradeDay),
//      Query.EQ("Sequence", tickInfo.Sequence));

//            WriteConcernResult result = null;
//            var preValue = _Collection.FindOneAs<OptionTickInfo>(query);
//            if (preValue != null)
//            {
//                tickInfo._id = preValue._id;
//                IMongoUpdate update = Update.Replace(tickInfo);
//                result = _Collection.Update(query, update, UpdateFlags.Upsert);
//            }
//            else
//            {
//                result = _Collection.Insert(tickInfo);
//            }
//            return result.Ok;
//        }

//        /// <summary>
//        /// 查询单代码指定交易日的Tick资料
//        /// </summary>
//        /// <param name="code">证券代码</param>
//        /// <param name="tradeday">交易日</param>
//        /// <returns></returns>
//        public List<OptionTickInfo> GetTicksByTradeDay(string code, uint tradeday)
//        {
//            if (string.IsNullOrEmpty(code) || _Collection == null)
//                return null;

//            return _Collection.AsQueryable<OptionTickInfo>()
//                .Where(x => x.TradeDay == tradeday && x.Code.Equals(code)).ToList();
//        }
//    }

//    /// <summary>
//    /// 日线数据归档集合
//    /// </summary>
//    internal class OptionDailyDataArchiverCollection : QuotationArchiverCollection
//    {
//        /// <summary>
//        /// 数据集合
//        /// </summary>
//        private MongoCollection _Collection = null;

//        /// <summary>
//        /// 构造器
//        /// </summary>
//        /// <param name="source"></param>
//        /// <param name="client"></param>
//        [DebuggerNonUserCode]
//        public OptionDailyDataArchiverCollection(QuotationSource source, MongoClient client)
//            : base(source, client)
//        {
//            _Collection = GetCollection<OptionDailyData>(QuotationArchiverType.DailyData);
//            if (_Collection == null)
//                throw new Exception(string.Format("初始化数据集合失败，Source:{0}", source));
//        }

//        /// <summary>
//        /// 将日线数据归档
//        /// </summary>
//        /// <param name="dailyData"></param>
//        /// <returns></returns>
//        public bool Archive(OptionDailyData dailyData)
//        {
//            if (_Collection == null)
//                return false;
//            IMongoQuery query = Query.And(
//Query.EQ("Code", dailyData.Code),
//Query.EQ("TradeDay", dailyData.TradeDay));


//            WriteConcernResult result = null;
//            var preValue = _Collection.FindOneAs<OptionDailyData>(query);
//            if (preValue != null)
//            {
//                dailyData._id = preValue._id;
//                IMongoUpdate update = Update.Replace(dailyData);
//                result = _Collection.Update(query, update, UpdateFlags.Upsert);
//            }
//            else
//            {
//                result = _Collection.Insert(dailyData);
//            }
//            return result.Ok;
//        }

//        /// <summary>
//        /// 查询单代码指定交易日的所有日线数据
//        /// </summary>
//        /// <param name="code">证券代码</param>
//        /// <param name="tradeday">交易日</param>
//        /// <returns></returns>
//        public OptionDailyData GetDatasByTradeDay(string code, uint tradeday)
//        {
//            if (string.IsNullOrEmpty(code) || _Collection == null)
//                return null;

//            return _Collection.AsQueryable<OptionDailyData>()
//                .Where(x => x.TradeDay == tradeday && x.Code.Equals(code)).FirstOrDefault();
//        }

//        /// <summary>
//        /// 查询单代码指定交易日范围内的所有日线数据
//        /// </summary>
//        /// <param name="code">证券代码</param>
//        /// <param name="startTradeday">起始交易日, 查询成功是，返回结果中第一条记录在全部数据中的序号(按日编序号)</param>
//        /// <param name="endTradeday">结束交易日, 查询成功是，返回结果中最后一条记录在全部数据中的序号(按日编序号)</param>
//        /// <returns></returns>
//        public List<OptionDailyData> GetDatasByTradeDay(string code, ref uint startTradeday, ref uint endTradeday)
//        {
//            List<OptionDailyData> result = new List<OptionDailyData>();
//            if (string.IsNullOrEmpty(code) || _Collection == null)
//                return result;

//            uint start = startTradeday;
//            uint end = endTradeday;

//            // 查询结果数据
//            var dailyDatas = _Collection.AsQueryable<OptionDailyData>().Where(x => x.TradeDay >= start && x.TradeDay <= end && x.Code.Equals(code));
//            foreach (var dailydata in dailyDatas)
//                result.Add(dailydata);

//            // 如果数据不为空，则查询起始序号
//            if (result.Count != 0)
//            {
//                int startIndex = _Collection.AsQueryable<OptionDailyData>()
//                    .Where(x => x.Code.Equals(code) && x.TradeDay < start).Count();

//                startTradeday = (uint)startIndex;
//                endTradeday = startTradeday + (uint)result.Count - 1;
//            }

//            return result;
//        }

//        /// <summary>
//        /// 查询单代码指定起、止序号的所有日线数据
//        /// </summary>
//        /// <param name="code">证券代码</param>
//        /// <param name="startIndex">起始序号, 查询成功是，返回结果中第一条记录在全部数据中的序号(按日编序号)</param>
//        /// <param name="endIndex">结束序号, 查询成功是，返回结果中最后一条记录在全部数据中的序号(按日编序号)</param>
//        /// <returns></returns>
//        public List<OptionDailyData> GetDatasByIndex(string code, ref int startIndex, ref int endIndex)
//        {
//            List<OptionDailyData> result = new List<OptionDailyData>();
//            if (string.IsNullOrEmpty(code) || _Collection == null)
//                return result;

//            // 检查序号是否有效
//            if (startIndex >= 0 && startIndex > endIndex)
//                return result;
//            else if (startIndex < 0 && startIndex < endIndex)
//                return result;

//            int totalcount = _Collection.AsQueryable<OptionDailyData>()
//                .Where(x => x.Code.Equals(code)).Count();


//            // 如果是倒序，则转换成正序
//            if (startIndex < 0)
//            {
//                int expectedCount = (int)Math.Abs(startIndex - endIndex + 1);
//                startIndex = totalcount + endIndex;
//                if (startIndex < 0)
//                    startIndex = 0;
//                endIndex = startIndex + expectedCount - 1;
//                if (endIndex >= totalcount)
//                    endIndex = totalcount - 1;
//            }
//            else
//            {
//                if (startIndex >= totalcount)
//                    return result;
//                if (endIndex >= totalcount)
//                    endIndex = totalcount - 1;
//            }

//            // 查询数据
//            int skipCount = startIndex;
//            int takeCount = endIndex - startIndex + 1;
//            var minuteDatas = _Collection.AsQueryable<OptionDailyData>()
//                                .Where(x => x.Code.Equals(code))
//                                .OrderBy(x => x.TradeDay)
//                                .Skip(skipCount)
//                                .Take(takeCount);

//            foreach (var minutedata in minuteDatas)
//                result.Add(minutedata);

//            return result;
//        }

//        /// <summary>
//        /// 查询单代码所有日线数据
//        /// </summary>
//        /// <param name="code">证券代码</param>
//        /// <returns></returns>
//        public List<OptionDailyData> GetAllDatas(string code)
//        {
//            if (string.IsNullOrEmpty(code))
//                return new List<OptionDailyData>();

//            // 查询结果数据
//            return _Collection.AsQueryable<OptionDailyData>().Where(x => x.Code.Equals(code)).ToList();
//        }

//        /// <summary>
//        /// 取日线的总数
//        /// </summary>
//        /// <param name="code"></param>
//        /// <returns></returns>
//        public int GetTotalCount(string code)
//        {
//            return _Collection.AsQueryable<OptionDailyData>().Where(x => x.Code.Equals(code)).Count();
//        }

//        /// <summary>
//        /// 查询给定交易日在数据中的序号
//        /// </summary>
//        /// <param name="code"></param>
//        /// <param name="tradeday"></param>
//        /// <returns>
//        ///             如果入参错误，则返回Int32.MinValue，
//        ///             如果给定交易日早于第一条数据，则返回-1，
//        ///             其它，则返回序号（实际按小于给定交易日的数据记录条数的汇总数）
//        /// </returns>
//        public int GetSequenceNoOfTradeday(string code, uint tradeday)
//        {
//            if (string.IsNullOrEmpty(code))
//                return Int32.MinValue;

//            var data = GetDatasByTradeDay(code, tradeday);
//            int count = _Collection.AsQueryable<OptionDailyData>()
//                .Where(x => x.Code.Equals(code) && x.TradeDay < tradeday).Count();

//            if (count == 0)
//                return data == null ? -1 : 0;
//            return count;
//        }

//    }

//    /// <summary>
//    /// 分线数据归档集合
//    /// </summary>
//    internal class OptionMinuteDataArchiverCollection : QuotationArchiverCollection
//    {
//        /// <summary>
//        /// 数据集合
//        /// </summary>
//        private MongoCollection _Collection = null;

//        /// <summary>
//        /// 构造器
//        /// </summary>
//        /// <param name="source"></param>
//        /// <param name="client"></param>
//        [DebuggerNonUserCode]
//        public OptionMinuteDataArchiverCollection(QuotationSource source, MongoClient client)
//            : base(source, client)
//        {
//            _Collection = GetCollection<FutureMinuteData>(QuotationArchiverType.MinuteData);
//            if (_Collection == null)
//                throw new Exception(string.Format("初始化数据集合失败，Source:{0}", source));
//        }

//        /// <summary>
//        /// 将分线数据归档
//        /// </summary>
//        /// <param name="minuteData"></param>
//        /// <returns></returns>
//        public bool Archive(OptionMinuteData minuteData)
//        {
//            if (_Collection == null)
//                return false;
//            IMongoQuery query = Query.And(
//Query.EQ("Code", minuteData.Code),
//Query.EQ("TradeDay", minuteData.TradeDay));

//            WriteConcernResult result = null;
//            var preValue = _Collection.FindOneAs<OptionMinuteData>(query);
//            if (preValue != null)
//            {
//                minuteData._id = preValue._id;
//                IMongoUpdate update = Update.Replace(minuteData);
//                result = _Collection.Update(query, update, UpdateFlags.Upsert);
//            }
//            else
//            {
//                result = _Collection.Insert(minuteData);
//            }
//            return result.Ok;
//        }

//        /// <summary>
//        /// 查询单代码指定交易日的所有分线数据
//        /// </summary>
//        /// <param name="code">证券代码</param>
//        /// <param name="tradeday">交易日</param>
//        /// <returns></returns>
//        public OptionMinuteData GetDatasByTradeDay(string code, uint tradeday)
//        {
//            if (string.IsNullOrEmpty(code) || _Collection == null)
//                return null;

//            return _Collection.AsQueryable<OptionMinuteData>()
//                    .Where(x => x.TradeDay == tradeday && x.Code.Equals(code)).FirstOrDefault();
//        }

//        /// <summary>
//        /// 查询单代码指定交易日的所有分线数据
//        /// </summary>
//        /// <param name="code">证券代码</param>
//        /// <param name="startTradeday">起始交易日, 查询成功是，返回结果中第一条记录在全部数据中的序号(按日编序号)</param>
//        /// <param name="endTradeday">结束交易日, 查询成功是，返回结果中最后一条记录在全部数据中的序号(按日编序号)</param>
//        /// <returns></returns>
//        public List<OptionMinuteData> GetDatasByTradeDay(string code, ref uint startTradeday, ref uint endTradeday)
//        {
//            List<OptionMinuteData> result = new List<OptionMinuteData>();
//            if (string.IsNullOrEmpty(code) || _Collection == null)
//                return result;

//            uint start = startTradeday;
//            uint end = endTradeday;

//            // 查询结果数据
//            var minuteDatas = _Collection.AsQueryable<OptionMinuteData>()
//                .Where(x => x.TradeDay >= start && x.TradeDay <= end && x.Code.Equals(code));

//            foreach (var minutedata in minuteDatas)
//                result.Add(minutedata);

//            // 如果数据不为空，则查询起始序号
//            if (result.Count != 0)
//            {
//                int startIndex = _Collection.AsQueryable<OptionMinuteData>()
//                    .Where(x => x.Code.Equals(code) && x.TradeDay < start).Count();

//                startTradeday = (uint)startIndex;
//                endTradeday = startTradeday + (uint)result.Count - 1;
//            }

//            return result;
//        }

//        /// <summary>
//        /// 查询单代码指定起、止序号的所有日线数据
//        /// </summary>
//        /// <param name="code">证券代码</param>
//        /// <param name="startIndex">起始序号, 查询成功是，返回结果中第一条记录在全部数据中的序号(按日编序号)</param>
//        /// <param name="endIndex">结束序号, 查询成功是，返回结果中最后一条记录在全部数据中的序号(按日编序号)</param>
//        /// <returns></returns>
//        public List<OptionMinuteData> GetDatasByIndex(string code, ref int startIndex, ref int endIndex)
//        {
//            List<OptionMinuteData> result = new List<OptionMinuteData>();
//            if (string.IsNullOrEmpty(code) || _Collection == null)
//                return result;

//            // 检查序号是否有效
//            if (startIndex >= 0 && startIndex > endIndex)
//                return result;
//            else if (startIndex < 0 && startIndex < endIndex)
//                return result;

//            int totalcount = _Collection.AsQueryable<OptionMinuteData>()
//                .Where(x => x.Code.Equals(code)).Count();

//            // 如果是倒序，则转换成正序
//            if (startIndex < 0)
//            {
//                int expectedCount = (int)Math.Abs(startIndex - endIndex + 1);
//                startIndex = totalcount + endIndex;
//                if (startIndex < 0)
//                    startIndex = 0;
//                endIndex = startIndex + expectedCount - 1;
//                if (endIndex >= totalcount)
//                    endIndex = totalcount - 1;
//            }
//            else
//            {
//                if (startIndex >= totalcount)
//                    return result;
//                if (endIndex >= totalcount)
//                    endIndex = totalcount - 1;
//            }

//            // 查询数据
//            int skipCount = startIndex;
//            int takeCount = endIndex - startIndex + 1;
//            var minuteDatas = _Collection.AsQueryable<OptionMinuteData>()
//                                .Where(x => x.Code.Equals(code))
//                                .OrderBy(x => x.TradeDay)
//                                .Skip(skipCount)
//                                .Take(takeCount);

//            foreach (var minutedata in minuteDatas)
//                result.Add(minutedata);

//            return result;
//        }

//        /// <summary>
//        /// 取分线的总数
//        /// </summary>
//        /// <param name="code"></param>
//        /// <returns></returns>
//        public int GetTotalCount(string code)
//        {
//            return _Collection.AsQueryable<OptionMinuteData>().Where(x => x.Code.Equals(code)).Count();
//        }

//        /// <summary>
//        /// 查询给定交易日在数据中的序号
//        /// </summary>
//        /// <param name="code"></param>
//        /// <param name="tradeday"></param>
//        /// <returns>
//        ///             如果入参错误，则返回Int32.MinValue，
//        ///             如果给定交易日早于第一条数据，则返回-1，
//        ///             其它，则返回序号（实际按小于给定交易日的数据记录条数的汇总数）
//        /// </returns>
//        public int GetSequenceNoOfTradeday(string code, uint tradeday)
//        {
//            if (string.IsNullOrEmpty(code))
//                return Int32.MinValue;

//            var data = GetDatasByTradeDay(code, tradeday);
//            int count = _Collection.AsQueryable<OptionMinuteData>()
//                .Where(x => x.Code.Equals(code) && x.TradeDay < tradeday).Count();

//            if (count == 0)
//                return data == null ? -1 : 0;
//            return count;
//        }
//    }

//    #endregion

//}
